// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/cubefs/cubefs/blobstore/blobnode/core (interfaces: DiskAPI,Storage,ChunkAPI)

// Package blobnode is a generated GoMock package.
package blobnode

import (
	context "context"
	io "io"
	reflect "reflect"

	blobnode "github.com/cubefs/cubefs/blobstore/api/blobnode"
	qos "github.com/cubefs/cubefs/blobstore/blobnode/base/qos"
	core "github.com/cubefs/cubefs/blobstore/blobnode/core"
	proto "github.com/cubefs/cubefs/blobstore/common/proto"
	gomock "github.com/golang/mock/gomock"
)

// MockDiskAPI is a mock of DiskAPI interface.
type MockDiskAPI struct {
	ctrl     *gomock.Controller
	recorder *MockDiskAPIMockRecorder
}

// MockDiskAPIMockRecorder is the mock recorder for MockDiskAPI.
type MockDiskAPIMockRecorder struct {
	mock *MockDiskAPI
}

// NewMockDiskAPI creates a new mock instance.
func NewMockDiskAPI(ctrl *gomock.Controller) *MockDiskAPI {
	mock := &MockDiskAPI{ctrl: ctrl}
	mock.recorder = &MockDiskAPIMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDiskAPI) EXPECT() *MockDiskAPIMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockDiskAPI) Close(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close", arg0)
}

// Close indicates an expected call of Close.
func (mr *MockDiskAPIMockRecorder) Close(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockDiskAPI)(nil).Close), arg0)
}

// CreateChunk mocks base method.
func (m *MockDiskAPI) CreateChunk(arg0 context.Context, arg1 proto.Vuid, arg2 int64) (core.ChunkAPI, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateChunk", arg0, arg1, arg2)
	ret0, _ := ret[0].(core.ChunkAPI)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateChunk indicates an expected call of CreateChunk.
func (mr *MockDiskAPIMockRecorder) CreateChunk(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChunk", reflect.TypeOf((*MockDiskAPI)(nil).CreateChunk), arg0, arg1, arg2)
}

// DiskInfo mocks base method.
func (m *MockDiskAPI) DiskInfo() blobnode.DiskInfo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DiskInfo")
	ret0, _ := ret[0].(blobnode.DiskInfo)
	return ret0
}

// DiskInfo indicates an expected call of DiskInfo.
func (mr *MockDiskAPIMockRecorder) DiskInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiskInfo", reflect.TypeOf((*MockDiskAPI)(nil).DiskInfo))
}

// EnqueueCompact mocks base method.
func (m *MockDiskAPI) EnqueueCompact(arg0 context.Context, arg1 proto.Vuid) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EnqueueCompact", arg0, arg1)
}

// EnqueueCompact indicates an expected call of EnqueueCompact.
func (mr *MockDiskAPIMockRecorder) EnqueueCompact(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnqueueCompact", reflect.TypeOf((*MockDiskAPI)(nil).EnqueueCompact), arg0, arg1)
}

// GcRubbishChunk mocks base method.
func (m *MockDiskAPI) GcRubbishChunk(arg0 context.Context) ([]blobnode.ChunkId, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GcRubbishChunk", arg0)
	ret0, _ := ret[0].([]blobnode.ChunkId)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GcRubbishChunk indicates an expected call of GcRubbishChunk.
func (mr *MockDiskAPIMockRecorder) GcRubbishChunk(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GcRubbishChunk", reflect.TypeOf((*MockDiskAPI)(nil).GcRubbishChunk), arg0)
}

// GetChunkStorage mocks base method.
func (m *MockDiskAPI) GetChunkStorage(arg0 proto.Vuid) (core.ChunkAPI, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChunkStorage", arg0)
	ret0, _ := ret[0].(core.ChunkAPI)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetChunkStorage indicates an expected call of GetChunkStorage.
func (mr *MockDiskAPIMockRecorder) GetChunkStorage(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChunkStorage", reflect.TypeOf((*MockDiskAPI)(nil).GetChunkStorage), arg0)
}

// GetConfig mocks base method.
func (m *MockDiskAPI) GetConfig() *core.Config {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfig")
	ret0, _ := ret[0].(*core.Config)
	return ret0
}

// GetConfig indicates an expected call of GetConfig.
func (mr *MockDiskAPIMockRecorder) GetConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfig", reflect.TypeOf((*MockDiskAPI)(nil).GetConfig))
}

// GetDataPath mocks base method.
func (m *MockDiskAPI) GetDataPath() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDataPath")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetDataPath indicates an expected call of GetDataPath.
func (mr *MockDiskAPIMockRecorder) GetDataPath() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataPath", reflect.TypeOf((*MockDiskAPI)(nil).GetDataPath))
}

// GetIoQos mocks base method.
func (m *MockDiskAPI) GetIoQos() qos.Qos {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIoQos")
	ret0, _ := ret[0].(qos.Qos)
	return ret0
}

// GetIoQos indicates an expected call of GetIoQos.
func (mr *MockDiskAPIMockRecorder) GetIoQos() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIoQos", reflect.TypeOf((*MockDiskAPI)(nil).GetIoQos))
}

// GetMetaPath mocks base method.
func (m *MockDiskAPI) GetMetaPath() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetaPath")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetMetaPath indicates an expected call of GetMetaPath.
func (mr *MockDiskAPIMockRecorder) GetMetaPath() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetaPath", reflect.TypeOf((*MockDiskAPI)(nil).GetMetaPath))
}

// ID mocks base method.
func (m *MockDiskAPI) ID() proto.DiskID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ID")
	ret0, _ := ret[0].(proto.DiskID)
	return ret0
}

// ID indicates an expected call of ID.
func (mr *MockDiskAPIMockRecorder) ID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockDiskAPI)(nil).ID))
}

// ListChunks mocks base method.
func (m *MockDiskAPI) ListChunks(arg0 context.Context) ([]core.VuidMeta, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChunks", arg0)
	ret0, _ := ret[0].([]core.VuidMeta)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListChunks indicates an expected call of ListChunks.
func (mr *MockDiskAPIMockRecorder) ListChunks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListChunks", reflect.TypeOf((*MockDiskAPI)(nil).ListChunks), arg0)
}

// LoadDiskInfo mocks base method.
func (m *MockDiskAPI) LoadDiskInfo(arg0 context.Context) (core.DiskMeta, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadDiskInfo", arg0)
	ret0, _ := ret[0].(core.DiskMeta)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LoadDiskInfo indicates an expected call of LoadDiskInfo.
func (mr *MockDiskAPIMockRecorder) LoadDiskInfo(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadDiskInfo", reflect.TypeOf((*MockDiskAPI)(nil).LoadDiskInfo), arg0)
}

// ReleaseChunk mocks base method.
func (m *MockDiskAPI) ReleaseChunk(arg0 context.Context, arg1 proto.Vuid, arg2 bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseChunk", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReleaseChunk indicates an expected call of ReleaseChunk.
func (mr *MockDiskAPIMockRecorder) ReleaseChunk(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseChunk", reflect.TypeOf((*MockDiskAPI)(nil).ReleaseChunk), arg0, arg1, arg2)
}

// ResetChunks mocks base method.
func (m *MockDiskAPI) ResetChunks(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ResetChunks", arg0)
}

// ResetChunks indicates an expected call of ResetChunks.
func (mr *MockDiskAPIMockRecorder) ResetChunks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetChunks", reflect.TypeOf((*MockDiskAPI)(nil).ResetChunks), arg0)
}

// SetStatus mocks base method.
func (m *MockDiskAPI) SetStatus(arg0 proto.DiskStatus) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStatus", arg0)
}

// SetStatus indicates an expected call of SetStatus.
func (mr *MockDiskAPIMockRecorder) SetStatus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStatus", reflect.TypeOf((*MockDiskAPI)(nil).SetStatus), arg0)
}

// Stats mocks base method.
func (m *MockDiskAPI) Stats() core.DiskStats {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stats")
	ret0, _ := ret[0].(core.DiskStats)
	return ret0
}

// Stats indicates an expected call of Stats.
func (mr *MockDiskAPIMockRecorder) Stats() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockDiskAPI)(nil).Stats))
}

// Status mocks base method.
func (m *MockDiskAPI) Status() proto.DiskStatus {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Status")
	ret0, _ := ret[0].(proto.DiskStatus)
	return ret0
}

// Status indicates an expected call of Status.
func (mr *MockDiskAPIMockRecorder) Status() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockDiskAPI)(nil).Status))
}

// UpdateChunkCompactState mocks base method.
func (m *MockDiskAPI) UpdateChunkCompactState(arg0 context.Context, arg1 proto.Vuid, arg2 bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChunkCompactState", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateChunkCompactState indicates an expected call of UpdateChunkCompactState.
func (mr *MockDiskAPIMockRecorder) UpdateChunkCompactState(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChunkCompactState", reflect.TypeOf((*MockDiskAPI)(nil).UpdateChunkCompactState), arg0, arg1, arg2)
}

// UpdateChunkStatus mocks base method.
func (m *MockDiskAPI) UpdateChunkStatus(arg0 context.Context, arg1 proto.Vuid, arg2 blobnode.ChunkStatus) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChunkStatus", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateChunkStatus indicates an expected call of UpdateChunkStatus.
func (mr *MockDiskAPIMockRecorder) UpdateChunkStatus(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChunkStatus", reflect.TypeOf((*MockDiskAPI)(nil).UpdateChunkStatus), arg0, arg1, arg2)
}

// UpdateDiskStatus mocks base method.
func (m *MockDiskAPI) UpdateDiskStatus(arg0 context.Context, arg1 proto.DiskStatus) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDiskStatus", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDiskStatus indicates an expected call of UpdateDiskStatus.
func (mr *MockDiskAPIMockRecorder) UpdateDiskStatus(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDiskStatus", reflect.TypeOf((*MockDiskAPI)(nil).UpdateDiskStatus), arg0, arg1)
}

// WalkChunksWithLock mocks base method.
func (m *MockDiskAPI) WalkChunksWithLock(arg0 context.Context, arg1 func(core.ChunkAPI) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WalkChunksWithLock", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// WalkChunksWithLock indicates an expected call of WalkChunksWithLock.
func (mr *MockDiskAPIMockRecorder) WalkChunksWithLock(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WalkChunksWithLock", reflect.TypeOf((*MockDiskAPI)(nil).WalkChunksWithLock), arg0, arg1)
}

// MockStorage is a mock of Storage interface.
type MockStorage struct {
	ctrl     *gomock.Controller
	recorder *MockStorageMockRecorder
}

// MockStorageMockRecorder is the mock recorder for MockStorage.
type MockStorageMockRecorder struct {
	mock *MockStorage
}

// NewMockStorage creates a new mock instance.
func NewMockStorage(ctrl *gomock.Controller) *MockStorage {
	mock := &MockStorage{ctrl: ctrl}
	mock.recorder = &MockStorageMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockStorage) EXPECT() *MockStorageMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockStorage) Close(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close", arg0)
}

// Close indicates an expected call of Close.
func (mr *MockStorageMockRecorder) Close(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStorage)(nil).Close), arg0)
}

// DataHandler mocks base method.
func (m *MockStorage) DataHandler() core.DataHandler {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DataHandler")
	ret0, _ := ret[0].(core.DataHandler)
	return ret0
}

// DataHandler indicates an expected call of DataHandler.
func (mr *MockStorageMockRecorder) DataHandler() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DataHandler", reflect.TypeOf((*MockStorage)(nil).DataHandler))
}

// DecrPendingCnt mocks base method.
func (m *MockStorage) DecrPendingCnt() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DecrPendingCnt")
}

// DecrPendingCnt indicates an expected call of DecrPendingCnt.
func (mr *MockStorageMockRecorder) DecrPendingCnt() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecrPendingCnt", reflect.TypeOf((*MockStorage)(nil).DecrPendingCnt))
}

// Delete mocks base method.
func (m *MockStorage) Delete(arg0 context.Context, arg1 proto.BlobID) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockStorageMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockStorage)(nil).Delete), arg0, arg1)
}

// Destroy mocks base method.
func (m *MockStorage) Destroy(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Destroy", arg0)
}

// Destroy indicates an expected call of Destroy.
func (mr *MockStorageMockRecorder) Destroy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Destroy", reflect.TypeOf((*MockStorage)(nil).Destroy), arg0)
}

// ID mocks base method.
func (m *MockStorage) ID() blobnode.ChunkId {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ID")
	ret0, _ := ret[0].(blobnode.ChunkId)
	return ret0
}

// ID indicates an expected call of ID.
func (mr *MockStorageMockRecorder) ID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockStorage)(nil).ID))
}

// IncrPendingCnt mocks base method.
func (m *MockStorage) IncrPendingCnt() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncrPendingCnt")
}

// IncrPendingCnt indicates an expected call of IncrPendingCnt.
func (mr *MockStorageMockRecorder) IncrPendingCnt() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrPendingCnt", reflect.TypeOf((*MockStorage)(nil).IncrPendingCnt))
}

// MarkDelete mocks base method.
func (m *MockStorage) MarkDelete(arg0 context.Context, arg1 proto.BlobID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkDelete", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// MarkDelete indicates an expected call of MarkDelete.
func (mr *MockStorageMockRecorder) MarkDelete(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkDelete", reflect.TypeOf((*MockStorage)(nil).MarkDelete), arg0, arg1)
}

// MetaHandler mocks base method.
func (m *MockStorage) MetaHandler() core.MetaHandler {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MetaHandler")
	ret0, _ := ret[0].(core.MetaHandler)
	return ret0
}

// MetaHandler indicates an expected call of MetaHandler.
func (mr *MockStorageMockRecorder) MetaHandler() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MetaHandler", reflect.TypeOf((*MockStorage)(nil).MetaHandler))
}

// NewRangeReader mocks base method.
func (m *MockStorage) NewRangeReader(arg0 context.Context, arg1 *core.Shard, arg2, arg3 int64) (io.Reader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRangeReader", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(io.Reader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewRangeReader indicates an expected call of NewRangeReader.
func (mr *MockStorageMockRecorder) NewRangeReader(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRangeReader", reflect.TypeOf((*MockStorage)(nil).NewRangeReader), arg0, arg1, arg2, arg3)
}

// PendingError mocks base method.
func (m *MockStorage) PendingError() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PendingError")
	ret0, _ := ret[0].(error)
	return ret0
}

// PendingError indicates an expected call of PendingError.
func (mr *MockStorageMockRecorder) PendingError() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingError", reflect.TypeOf((*MockStorage)(nil).PendingError))
}

// PendingRequest mocks base method.
func (m *MockStorage) PendingRequest() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PendingRequest")
	ret0, _ := ret[0].(int64)
	return ret0
}

// PendingRequest indicates an expected call of PendingRequest.
func (mr *MockStorageMockRecorder) PendingRequest() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PendingRequest", reflect.TypeOf((*MockStorage)(nil).PendingRequest))
}

// RawStorage mocks base method.
func (m *MockStorage) RawStorage() core.Storage {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RawStorage")
	ret0, _ := ret[0].(core.Storage)
	return ret0
}

// RawStorage indicates an expected call of RawStorage.
func (mr *MockStorageMockRecorder) RawStorage() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RawStorage", reflect.TypeOf((*MockStorage)(nil).RawStorage))
}

// ReadShardMeta mocks base method.
func (m *MockStorage) ReadShardMeta(arg0 context.Context, arg1 proto.BlobID) (*core.ShardMeta, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadShardMeta", arg0, arg1)
	ret0, _ := ret[0].(*core.ShardMeta)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadShardMeta indicates an expected call of ReadShardMeta.
func (mr *MockStorageMockRecorder) ReadShardMeta(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadShardMeta", reflect.TypeOf((*MockStorage)(nil).ReadShardMeta), arg0, arg1)
}

// ScanMeta mocks base method.
func (m *MockStorage) ScanMeta(arg0 context.Context, arg1 proto.BlobID, arg2 int, arg3 func(proto.BlobID, *core.ShardMeta) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanMeta", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanMeta indicates an expected call of ScanMeta.
func (mr *MockStorageMockRecorder) ScanMeta(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanMeta", reflect.TypeOf((*MockStorage)(nil).ScanMeta), arg0, arg1, arg2, arg3)
}

// Stat mocks base method.
func (m *MockStorage) Stat(arg0 context.Context) (*core.StorageStat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stat", arg0)
	ret0, _ := ret[0].(*core.StorageStat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stat indicates an expected call of Stat.
func (mr *MockStorageMockRecorder) Stat(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stat", reflect.TypeOf((*MockStorage)(nil).Stat), arg0)
}

// Sync mocks base method.
func (m *MockStorage) Sync(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sync", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Sync indicates an expected call of Sync.
func (mr *MockStorageMockRecorder) Sync(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync", reflect.TypeOf((*MockStorage)(nil).Sync), arg0)
}

// SyncData mocks base method.
func (m *MockStorage) SyncData(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncData", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SyncData indicates an expected call of SyncData.
func (mr *MockStorageMockRecorder) SyncData(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncData", reflect.TypeOf((*MockStorage)(nil).SyncData), arg0)
}

// Write mocks base method.
func (m *MockStorage) Write(arg0 context.Context, arg1 *core.Shard) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Write indicates an expected call of Write.
func (mr *MockStorageMockRecorder) Write(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockStorage)(nil).Write), arg0, arg1)
}

// MockChunkAPI is a mock of ChunkAPI interface.
type MockChunkAPI struct {
	ctrl     *gomock.Controller
	recorder *MockChunkAPIMockRecorder
}

// MockChunkAPIMockRecorder is the mock recorder for MockChunkAPI.
type MockChunkAPIMockRecorder struct {
	mock *MockChunkAPI
}

// NewMockChunkAPI creates a new mock instance.
func NewMockChunkAPI(ctrl *gomock.Controller) *MockChunkAPI {
	mock := &MockChunkAPI{ctrl: ctrl}
	mock.recorder = &MockChunkAPIMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockChunkAPI) EXPECT() *MockChunkAPIMockRecorder {
	return m.recorder
}

// AllowModify mocks base method.
func (m *MockChunkAPI) AllowModify() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllowModify")
	ret0, _ := ret[0].(error)
	return ret0
}

// AllowModify indicates an expected call of AllowModify.
func (mr *MockChunkAPIMockRecorder) AllowModify() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllowModify", reflect.TypeOf((*MockChunkAPI)(nil).AllowModify))
}

// ChunkInfo mocks base method.
func (m *MockChunkAPI) ChunkInfo(arg0 context.Context) blobnode.ChunkInfo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChunkInfo", arg0)
	ret0, _ := ret[0].(blobnode.ChunkInfo)
	return ret0
}

// ChunkInfo indicates an expected call of ChunkInfo.
func (mr *MockChunkAPIMockRecorder) ChunkInfo(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChunkInfo", reflect.TypeOf((*MockChunkAPI)(nil).ChunkInfo), arg0)
}

// Close mocks base method.
func (m *MockChunkAPI) Close(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close", arg0)
}

// Close indicates an expected call of Close.
func (mr *MockChunkAPIMockRecorder) Close(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockChunkAPI)(nil).Close), arg0)
}

// CommitCompact mocks base method.
func (m *MockChunkAPI) CommitCompact(arg0 context.Context, arg1 core.ChunkAPI) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommitCompact", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CommitCompact indicates an expected call of CommitCompact.
func (mr *MockChunkAPIMockRecorder) CommitCompact(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitCompact", reflect.TypeOf((*MockChunkAPI)(nil).CommitCompact), arg0, arg1)
}

// Delete mocks base method.
func (m *MockChunkAPI) Delete(arg0 context.Context, arg1 proto.BlobID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockChunkAPIMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockChunkAPI)(nil).Delete), arg0, arg1)
}

// Disk mocks base method.
func (m *MockChunkAPI) Disk() core.DiskAPI {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Disk")
	ret0, _ := ret[0].(core.DiskAPI)
	return ret0
}

// Disk indicates an expected call of Disk.
func (mr *MockChunkAPIMockRecorder) Disk() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Disk", reflect.TypeOf((*MockChunkAPI)(nil).Disk))
}

// HasEnoughSpace mocks base method.
func (m *MockChunkAPI) HasEnoughSpace(arg0 int64) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasEnoughSpace", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// HasEnoughSpace indicates an expected call of HasEnoughSpace.
func (mr *MockChunkAPIMockRecorder) HasEnoughSpace(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasEnoughSpace", reflect.TypeOf((*MockChunkAPI)(nil).HasEnoughSpace), arg0)
}

// HasPendingRequest mocks base method.
func (m *MockChunkAPI) HasPendingRequest() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasPendingRequest")
	ret0, _ := ret[0].(bool)
	return ret0
}

// HasPendingRequest indicates an expected call of HasPendingRequest.
func (mr *MockChunkAPIMockRecorder) HasPendingRequest() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasPendingRequest", reflect.TypeOf((*MockChunkAPI)(nil).HasPendingRequest))
}

// ID mocks base method.
func (m *MockChunkAPI) ID() blobnode.ChunkId {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ID")
	ret0, _ := ret[0].(blobnode.ChunkId)
	return ret0
}

// ID indicates an expected call of ID.
func (mr *MockChunkAPIMockRecorder) ID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockChunkAPI)(nil).ID))
}

// IsClosed mocks base method.
func (m *MockChunkAPI) IsClosed() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsClosed")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsClosed indicates an expected call of IsClosed.
func (mr *MockChunkAPIMockRecorder) IsClosed() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsClosed", reflect.TypeOf((*MockChunkAPI)(nil).IsClosed))
}

// IsDirty mocks base method.
func (m *MockChunkAPI) IsDirty() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsDirty")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsDirty indicates an expected call of IsDirty.
func (mr *MockChunkAPIMockRecorder) IsDirty() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsDirty", reflect.TypeOf((*MockChunkAPI)(nil).IsDirty))
}

// ListShards mocks base method.
func (m *MockChunkAPI) ListShards(arg0 context.Context, arg1 proto.BlobID, arg2 int, arg3 blobnode.ShardStatus) ([]*blobnode.ShardInfo, proto.BlobID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListShards", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*blobnode.ShardInfo)
	ret1, _ := ret[1].(proto.BlobID)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListShards indicates an expected call of ListShards.
func (mr *MockChunkAPIMockRecorder) ListShards(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListShards", reflect.TypeOf((*MockChunkAPI)(nil).ListShards), arg0, arg1, arg2, arg3)
}

// MarkDelete mocks base method.
func (m *MockChunkAPI) MarkDelete(arg0 context.Context, arg1 proto.BlobID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkDelete", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// MarkDelete indicates an expected call of MarkDelete.
func (mr *MockChunkAPIMockRecorder) MarkDelete(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkDelete", reflect.TypeOf((*MockChunkAPI)(nil).MarkDelete), arg0, arg1)
}

// NeedCompact mocks base method.
func (m *MockChunkAPI) NeedCompact(arg0 context.Context) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NeedCompact", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// NeedCompact indicates an expected call of NeedCompact.
func (mr *MockChunkAPIMockRecorder) NeedCompact(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NeedCompact", reflect.TypeOf((*MockChunkAPI)(nil).NeedCompact), arg0)
}

// RangeRead mocks base method.
func (m *MockChunkAPI) RangeRead(arg0 context.Context, arg1 *core.Shard) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RangeRead", arg0, arg1)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RangeRead indicates an expected call of RangeRead.
func (mr *MockChunkAPIMockRecorder) RangeRead(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeRead", reflect.TypeOf((*MockChunkAPI)(nil).RangeRead), arg0, arg1)
}

// Read mocks base method.
func (m *MockChunkAPI) Read(arg0 context.Context, arg1 *core.Shard) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", arg0, arg1)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockChunkAPIMockRecorder) Read(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockChunkAPI)(nil).Read), arg0, arg1)
}

// ReadShardMeta mocks base method.
func (m *MockChunkAPI) ReadShardMeta(arg0 context.Context, arg1 proto.BlobID) (*core.ShardMeta, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadShardMeta", arg0, arg1)
	ret0, _ := ret[0].(*core.ShardMeta)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadShardMeta indicates an expected call of ReadShardMeta.
func (mr *MockChunkAPIMockRecorder) ReadShardMeta(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadShardMeta", reflect.TypeOf((*MockChunkAPI)(nil).ReadShardMeta), arg0, arg1)
}

// SetDirty mocks base method.
func (m *MockChunkAPI) SetDirty(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetDirty", arg0)
}

// SetDirty indicates an expected call of SetDirty.
func (mr *MockChunkAPIMockRecorder) SetDirty(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDirty", reflect.TypeOf((*MockChunkAPI)(nil).SetDirty), arg0)
}

// SetStatus mocks base method.
func (m *MockChunkAPI) SetStatus(arg0 blobnode.ChunkStatus) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetStatus", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetStatus indicates an expected call of SetStatus.
func (mr *MockChunkAPIMockRecorder) SetStatus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStatus", reflect.TypeOf((*MockChunkAPI)(nil).SetStatus), arg0)
}

// StartCompact mocks base method.
func (m *MockChunkAPI) StartCompact(arg0 context.Context) (core.ChunkAPI, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartCompact", arg0)
	ret0, _ := ret[0].(core.ChunkAPI)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartCompact indicates an expected call of StartCompact.
func (mr *MockChunkAPIMockRecorder) StartCompact(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartCompact", reflect.TypeOf((*MockChunkAPI)(nil).StartCompact), arg0)
}

// Status mocks base method.
func (m *MockChunkAPI) Status() blobnode.ChunkStatus {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Status")
	ret0, _ := ret[0].(blobnode.ChunkStatus)
	return ret0
}

// Status indicates an expected call of Status.
func (mr *MockChunkAPIMockRecorder) Status() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockChunkAPI)(nil).Status))
}

// StopCompact mocks base method.
func (m *MockChunkAPI) StopCompact(arg0 context.Context, arg1 core.ChunkAPI) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopCompact", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// StopCompact indicates an expected call of StopCompact.
func (mr *MockChunkAPIMockRecorder) StopCompact(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopCompact", reflect.TypeOf((*MockChunkAPI)(nil).StopCompact), arg0, arg1)
}

// Sync mocks base method.
func (m *MockChunkAPI) Sync(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sync", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Sync indicates an expected call of Sync.
func (mr *MockChunkAPIMockRecorder) Sync(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync", reflect.TypeOf((*MockChunkAPI)(nil).Sync), arg0)
}

// SyncData mocks base method.
func (m *MockChunkAPI) SyncData(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncData", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SyncData indicates an expected call of SyncData.
func (mr *MockChunkAPIMockRecorder) SyncData(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncData", reflect.TypeOf((*MockChunkAPI)(nil).SyncData), arg0)
}

// Vuid mocks base method.
func (m *MockChunkAPI) Vuid() proto.Vuid {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Vuid")
	ret0, _ := ret[0].(proto.Vuid)
	return ret0
}

// Vuid indicates an expected call of Vuid.
func (mr *MockChunkAPIMockRecorder) Vuid() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Vuid", reflect.TypeOf((*MockChunkAPI)(nil).Vuid))
}

// VuidMeta mocks base method.
func (m *MockChunkAPI) VuidMeta() *core.VuidMeta {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VuidMeta")
	ret0, _ := ret[0].(*core.VuidMeta)
	return ret0
}

// VuidMeta indicates an expected call of VuidMeta.
func (mr *MockChunkAPIMockRecorder) VuidMeta() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VuidMeta", reflect.TypeOf((*MockChunkAPI)(nil).VuidMeta))
}

// Write mocks base method.
func (m *MockChunkAPI) Write(arg0 context.Context, arg1 *core.Shard) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Write indicates an expected call of Write.
func (mr *MockChunkAPIMockRecorder) Write(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockChunkAPI)(nil).Write), arg0, arg1)
}
